home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / iso_fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-10-13  |  11.6 KB  |  313 lines
  1.  
  2. #ifndef _ISOFS_FS_H
  3. #define _ISOFS_FS_H
  4.  
  5. #include <linux/types.h>
  6. /*
  7.  * The isofs filesystem constants/structures
  8.  */
  9.  
  10. /* This part borrowed from the bsd386 isofs */
  11. #define ISODCL(from, to) (to - from + 1)
  12.  
  13. struct iso_volume_descriptor {
  14.     char type[ISODCL(1,1)]; /* 711 */
  15.     char id[ISODCL(2,6)];
  16.     char version[ISODCL(7,7)];
  17.     char data[ISODCL(8,2048)];
  18. };
  19.  
  20. /* volume descriptor types */
  21. #define ISO_VD_PRIMARY 1
  22. #define ISO_VD_SUPPLEMENTARY 2
  23. #define ISO_VD_END 255
  24.  
  25. #define ISO_STANDARD_ID "CD001"
  26.  
  27. struct iso_primary_descriptor {
  28.     char type            [ISODCL (  1,   1)]; /* 711 */
  29.     char id                [ISODCL (  2,   6)];
  30.     char version            [ISODCL (  7,   7)]; /* 711 */
  31.     char unused1            [ISODCL (  8,   8)];
  32.     char system_id            [ISODCL (  9,  40)]; /* achars */
  33.     char volume_id            [ISODCL ( 41,  72)]; /* dchars */
  34.     char unused2            [ISODCL ( 73,  80)];
  35.     char volume_space_size        [ISODCL ( 81,  88)]; /* 733 */
  36.     char unused3            [ISODCL ( 89, 120)];
  37.     char volume_set_size        [ISODCL (121, 124)]; /* 723 */
  38.     char volume_sequence_number    [ISODCL (125, 128)]; /* 723 */
  39.     char logical_block_size        [ISODCL (129, 132)]; /* 723 */
  40.     char path_table_size        [ISODCL (133, 140)]; /* 733 */
  41.     char type_l_path_table        [ISODCL (141, 144)]; /* 731 */
  42.     char opt_type_l_path_table    [ISODCL (145, 148)]; /* 731 */
  43.     char type_m_path_table        [ISODCL (149, 152)]; /* 732 */
  44.     char opt_type_m_path_table    [ISODCL (153, 156)]; /* 732 */
  45.     char root_directory_record    [ISODCL (157, 190)]; /* 9.1 */
  46.     char volume_set_id        [ISODCL (191, 318)]; /* dchars */
  47.     char publisher_id        [ISODCL (319, 446)]; /* achars */
  48.     char preparer_id        [ISODCL (447, 574)]; /* achars */
  49.     char application_id        [ISODCL (575, 702)]; /* achars */
  50.     char copyright_file_id        [ISODCL (703, 739)]; /* 7.5 dchars */
  51.     char abstract_file_id        [ISODCL (740, 776)]; /* 7.5 dchars */
  52.     char bibliographic_file_id    [ISODCL (777, 813)]; /* 7.5 dchars */
  53.     char creation_date        [ISODCL (814, 830)]; /* 8.4.26.1 */
  54.     char modification_date        [ISODCL (831, 847)]; /* 8.4.26.1 */
  55.     char expiration_date        [ISODCL (848, 864)]; /* 8.4.26.1 */
  56.     char effective_date        [ISODCL (865, 881)]; /* 8.4.26.1 */
  57.     char file_structure_version    [ISODCL (882, 882)]; /* 711 */
  58.     char unused4            [ISODCL (883, 883)];
  59.     char application_data        [ISODCL (884, 1395)];
  60.     char unused5            [ISODCL (1396, 2048)];
  61. };
  62.  
  63. /* Almost the same as the primary descriptor but two fields are specified */
  64. struct iso_supplementary_descriptor {
  65.     char type            [ISODCL (  1,   1)]; /* 711 */
  66.     char id                [ISODCL (  2,   6)];
  67.     char version            [ISODCL (  7,   7)]; /* 711 */
  68.     char flags            [ISODCL (  8,   8)]; /* 853 */
  69.     char system_id            [ISODCL (  9,  40)]; /* achars */
  70.     char volume_id            [ISODCL ( 41,  72)]; /* dchars */
  71.     char unused2            [ISODCL ( 73,  80)];
  72.     char volume_space_size        [ISODCL ( 81,  88)]; /* 733 */
  73.     char escape            [ISODCL ( 89, 120)]; /* 856 */
  74.     char volume_set_size        [ISODCL (121, 124)]; /* 723 */
  75.     char volume_sequence_number    [ISODCL (125, 128)]; /* 723 */
  76.     char logical_block_size        [ISODCL (129, 132)]; /* 723 */
  77.     char path_table_size        [ISODCL (133, 140)]; /* 733 */
  78.     char type_l_path_table        [ISODCL (141, 144)]; /* 731 */
  79.     char opt_type_l_path_table    [ISODCL (145, 148)]; /* 731 */
  80.     char type_m_path_table        [ISODCL (149, 152)]; /* 732 */
  81.     char opt_type_m_path_table    [ISODCL (153, 156)]; /* 732 */
  82.     char root_directory_record    [ISODCL (157, 190)]; /* 9.1 */
  83.     char volume_set_id        [ISODCL (191, 318)]; /* dchars */
  84.     char publisher_id        [ISODCL (319, 446)]; /* achars */
  85.     char preparer_id        [ISODCL (447, 574)]; /* achars */
  86.     char application_id        [ISODCL (575, 702)]; /* achars */
  87.     char copyright_file_id        [ISODCL (703, 739)]; /* 7.5 dchars */
  88.     char abstract_file_id        [ISODCL (740, 776)]; /* 7.5 dchars */
  89.     char bibliographic_file_id    [ISODCL (777, 813)]; /* 7.5 dchars */
  90.     char creation_date        [ISODCL (814, 830)]; /* 8.4.26.1 */
  91.     char modification_date        [ISODCL (831, 847)]; /* 8.4.26.1 */
  92.     char expiration_date        [ISODCL (848, 864)]; /* 8.4.26.1 */
  93.     char effective_date        [ISODCL (865, 881)]; /* 8.4.26.1 */
  94.     char file_structure_version    [ISODCL (882, 882)]; /* 711 */
  95.     char unused4            [ISODCL (883, 883)];
  96.     char application_data        [ISODCL (884, 1395)];
  97.     char unused5            [ISODCL (1396, 2048)];
  98. };
  99.  
  100.  
  101. #define HS_STANDARD_ID "CDROM"
  102.  
  103. struct  hs_volume_descriptor {
  104.     char foo            [ISODCL (  1,   8)]; /* 733 */
  105.     char type            [ISODCL (  9,   9)]; /* 711 */
  106.     char id                [ISODCL ( 10,  14)];
  107.     char version            [ISODCL ( 15,  15)]; /* 711 */
  108.     char data[ISODCL(16,2048)];
  109. };
  110.  
  111.  
  112. struct hs_primary_descriptor {
  113.     char foo            [ISODCL (  1,   8)]; /* 733 */
  114.     char type            [ISODCL (  9,   9)]; /* 711 */
  115.     char id                [ISODCL ( 10,  14)];
  116.     char version            [ISODCL ( 15,  15)]; /* 711 */
  117.     char unused1            [ISODCL ( 16,  16)]; /* 711 */
  118.     char system_id            [ISODCL ( 17,  48)]; /* achars */
  119.     char volume_id            [ISODCL ( 49,  80)]; /* dchars */
  120.     char unused2            [ISODCL ( 81,  88)]; /* 733 */
  121.     char volume_space_size        [ISODCL ( 89,  96)]; /* 733 */
  122.     char unused3            [ISODCL ( 97, 128)]; /* 733 */
  123.     char volume_set_size        [ISODCL (129, 132)]; /* 723 */
  124.     char volume_sequence_number    [ISODCL (133, 136)]; /* 723 */
  125.     char logical_block_size        [ISODCL (137, 140)]; /* 723 */
  126.     char path_table_size        [ISODCL (141, 148)]; /* 733 */
  127.     char type_l_path_table        [ISODCL (149, 152)]; /* 731 */
  128.     char unused4            [ISODCL (153, 180)]; /* 733 */
  129.     char root_directory_record    [ISODCL (181, 214)]; /* 9.1 */
  130. };
  131.  
  132. /* We use this to help us look up the parent inode numbers. */
  133.  
  134. struct iso_path_table{
  135.     unsigned char  name_len[2];    /* 721 */
  136.     char extent[4];        /* 731 */
  137.     char  parent[2];    /* 721 */
  138.     char name[0];
  139. } __attribute__((packed));
  140.  
  141. /* high sierra is identical to iso, except that the date is only 6 bytes, and
  142.    there is an extra reserved byte after the flags */
  143.  
  144. struct iso_directory_record {
  145.     char length            [ISODCL (1, 1)]; /* 711 */
  146.     char ext_attr_length        [ISODCL (2, 2)]; /* 711 */
  147.     char extent            [ISODCL (3, 10)]; /* 733 */
  148.     char size            [ISODCL (11, 18)]; /* 733 */
  149.     char date            [ISODCL (19, 25)]; /* 7 by 711 */
  150.     char flags            [ISODCL (26, 26)];
  151.     char file_unit_size        [ISODCL (27, 27)]; /* 711 */
  152.     char interleave            [ISODCL (28, 28)]; /* 711 */
  153.     char volume_sequence_number    [ISODCL (29, 32)]; /* 723 */
  154.     unsigned char name_len        [ISODCL (33, 33)]; /* 711 */
  155.     char name            [0];
  156. } __attribute__((packed));
  157.  
  158. #define ISOFS_BLOCK_BITS 11
  159. #define ISOFS_BLOCK_SIZE 2048
  160.  
  161. #define ISOFS_BUFFER_SIZE(INODE) ((INODE)->i_sb->s_blocksize)
  162. #define ISOFS_BUFFER_BITS(INODE) ((INODE)->i_sb->s_blocksize_bits)
  163.  
  164. #define ISOFS_SUPER_MAGIC 0x9660
  165.  
  166. #ifdef __KERNEL__
  167. /* Number conversion inlines, named after the section in ISO 9660
  168.    they correspond to. */
  169.  
  170. #include <asm/byteorder.h>
  171. #include <asm/unaligned.h>
  172. #include <linux/iso_fs_i.h>
  173. #include <linux/iso_fs_sb.h>
  174.  
  175. static inline struct isofs_sb_info *ISOFS_SB(struct super_block *sb)
  176. {
  177.     return sb->s_fs_info;
  178. }
  179.  
  180. static inline struct iso_inode_info *ISOFS_I(struct inode *inode)
  181. {
  182.     return container_of(inode, struct iso_inode_info, vfs_inode);
  183. }
  184.  
  185. static inline int isonum_711(char *p)
  186. {
  187.     return *(u8 *)p;
  188. }
  189. static inline int isonum_712(char *p)
  190. {
  191.     return *(s8 *)p;
  192. }
  193. static inline unsigned int isonum_721(char *p)
  194. {
  195.     return le16_to_cpu(get_unaligned((__le16 *)p));
  196. }
  197. static inline unsigned int isonum_722(char *p)
  198. {
  199.     return be16_to_cpu(get_unaligned((__le16 *)p));
  200. }
  201. static inline unsigned int isonum_723(char *p)
  202. {
  203.     /* Ignore bigendian datum due to broken mastering programs */
  204.     return le16_to_cpu(get_unaligned((__le16 *)p));
  205. }
  206. static inline unsigned int isonum_731(char *p)
  207. {
  208.     return le32_to_cpu(get_unaligned((__le32 *)p));
  209. }
  210. static inline unsigned int isonum_732(char *p)
  211. {
  212.     return be32_to_cpu(get_unaligned((__le32 *)p));
  213. }
  214. static inline unsigned int isonum_733(char *p)
  215. {
  216.     /* Ignore bigendian datum due to broken mastering programs */
  217.     return le32_to_cpu(get_unaligned((__le32 *)p));
  218. }
  219. extern int iso_date(char *, int);
  220.  
  221. struct inode;        /* To make gcc happy */
  222.  
  223. extern int parse_rock_ridge_inode(struct iso_directory_record *, struct inode *);
  224. extern int get_rock_ridge_filename(struct iso_directory_record *, char *, struct inode *);
  225. extern int isofs_name_translate(struct iso_directory_record *, char *, struct inode *);
  226.  
  227. int get_joliet_filename(struct iso_directory_record *, unsigned char *, struct inode *);
  228. int get_acorn_filename(struct iso_directory_record *, char *, struct inode *);
  229.  
  230. extern struct dentry *isofs_lookup(struct inode *, struct dentry *, struct nameidata *);
  231. extern struct buffer_head *isofs_bread(struct inode *, sector_t);
  232. extern int isofs_get_blocks(struct inode *, sector_t, struct buffer_head **, unsigned long);
  233.  
  234. extern struct inode *isofs_iget(struct super_block *sb,
  235.                                 unsigned long block,
  236.                                 unsigned long offset);
  237.  
  238. /* Because the inode number is no longer relevant to finding the
  239.  * underlying meta-data for an inode, we are free to choose a more
  240.  * convenient 32-bit number as the inode number.  The inode numbering
  241.  * scheme was recommended by Sergey Vlasov and Eric Lammerts. */
  242. static inline unsigned long isofs_get_ino(unsigned long block,
  243.                       unsigned long offset,
  244.                       unsigned long bufbits)
  245. {
  246.     return (block << (bufbits - 5)) | (offset >> 5);
  247. }
  248.  
  249. /* Every directory can have many redundant directory entries scattered
  250.  * throughout the directory tree.  First there is the directory entry
  251.  * with the name of the directory stored in the parent directory.
  252.  * Then, there is the "." directory entry stored in the directory
  253.  * itself.  Finally, there are possibly many ".." directory entries
  254.  * stored in all the subdirectories.
  255.  *
  256.  * In order for the NFS get_parent() method to work and for the
  257.  * general consistency of the dcache, we need to make sure the
  258.  * "i_iget5_block" and "i_iget5_offset" all point to exactly one of
  259.  * the many redundant entries for each directory.  We normalize the
  260.  * block and offset by always making them point to the "."  directory.
  261.  *
  262.  * Notice that we do not use the entry for the directory with the name
  263.  * that is located in the parent directory.  Even though choosing this
  264.  * first directory is more natural, it is much easier to find the "."
  265.  * entry in the NFS get_parent() method because it is implicitly
  266.  * encoded in the "extent + ext_attr_length" fields of _all_ the
  267.  * redundant entries for the directory.  Thus, it can always be
  268.  * reached regardless of which directory entry you have in hand.
  269.  *
  270.  * This works because the "." entry is simply the first directory
  271.  * record when you start reading the file that holds all the directory
  272.  * records, and this file starts at "extent + ext_attr_length" blocks.
  273.  * Because the "." entry is always the first entry listed in the
  274.  * directories file, the normalized "offset" value is always 0.
  275.  *
  276.  * You should pass the directory entry in "de".  On return, "block"
  277.  * and "offset" will hold normalized values.  Only directories are
  278.  * affected making it safe to call even for non-directory file
  279.  * types. */
  280. static inline void
  281. isofs_normalize_block_and_offset(struct iso_directory_record* de,
  282.                  unsigned long *block,
  283.                  unsigned long *offset)
  284. {
  285.     /* Only directories are normalized. */
  286.     if (de->flags[0] & 2) {
  287.         *offset = 0;
  288.         *block = (unsigned long)isonum_733(de->extent)
  289.             + (unsigned long)isonum_711(de->ext_attr_length);
  290.     }
  291. }
  292.  
  293. extern struct inode_operations isofs_dir_inode_operations;
  294. extern struct file_operations isofs_dir_operations;
  295. extern struct address_space_operations isofs_symlink_aops;
  296. extern struct export_operations isofs_export_ops;
  297.  
  298. /* The following macros are used to check for memory leaks. */
  299. #ifdef LEAK_CHECK
  300. #define free_s leak_check_free_s
  301. #define malloc leak_check_malloc
  302. #define sb_bread leak_check_bread
  303. #define brelse leak_check_brelse
  304. extern void * leak_check_malloc(unsigned int size);
  305. extern void leak_check_free_s(void * obj, int size);
  306. extern struct buffer_head * leak_check_bread(struct super_block *sb, int block);
  307. extern void leak_check_brelse(struct buffer_head * bh);
  308. #endif /* LEAK_CHECK */
  309.  
  310. #endif /* __KERNEL__ */
  311.  
  312. #endif
  313.